home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / N-P / NIFTY / myCShell / ADBLights.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-17  |  6.1 KB  |  266 lines  |  [TEXT/KAHL]
  1. /***********************************************************
  2.  "ADBLights.c"
  3.  
  4.  Routines for controlling the lights on an extended keyboard
  5.  
  6.     (C)    1991 SPLAsh Resources. All rights reserved.
  7.         [ See "THINKin' CaP", Winter 1991 ]
  8.  
  9.  using Symantec's "THINK C", v 5.00
  10.  ***********************************************************/
  11.  
  12.  
  13.  
  14. #include <DeskBus.h>
  15. #include <GestaltEqu.h>
  16. #include <Traps.h>
  17. #include "ADBLights.h"
  18.  
  19. #include "protos"
  20.  
  21. #include "globals.h"
  22. #include "extern.h"
  23.  
  24.  
  25.  
  26.  
  27. /* ++++++++++++++++++++
  28. ** Our local prototype:
  29. ** ++++++++++++++++++++ */
  30.  
  31. pascal void    ADBCompletion (void);
  32.  
  33.  
  34.  
  35.     #define        Type_ExtKbd        2
  36.     #define        Addr_ExtKbd        2
  37.  
  38.     #define        Talk_Reg2        0x0E
  39.     #define        Listen_Reg2        0x0A
  40.  
  41.     #define        Bit_NumLock        0x01
  42.     #define        Bit_CapsLock    0x02
  43.     #define        Bit_ScrollLock    0x04
  44.  
  45.  
  46.  
  47.  
  48. Boolean    hasADB (void)    {
  49.  
  50.     return (TrapAvailable(_ADBOp));
  51.     
  52. }    /* hasADB */
  53.  
  54.  
  55.  
  56. Boolean    hasExtendedKybd (void)    {
  57.  
  58.         Boolean        result;
  59.         long        myFeature;
  60.         OSErr        whoCares;
  61.         SysEnvRec    theWorld;
  62.         
  63.         
  64.     if (TrapAvailable(_GestaltDispatch))
  65.         result = (
  66.                   (Gestalt(gestaltKeyboardType, &myFeature) == noErr)
  67.                   &&
  68.                   BitTst(&myFeature, 31 - gestaltExtADBKbd)
  69.                  );
  70.     else    {
  71.         whoCares = SysEnvirons(1, &theWorld);
  72.         result = (theWorld.keyBoardType == envAExtendKbd);
  73.     }
  74.         
  75.     
  76. }    /* hasExtendedKybd */
  77.  
  78.  
  79.  
  80. /* ---------------------------------------
  81. ** Return the number of extended keyboards
  82. ** and a list of their addresses
  83. ** --------------------------------------- */
  84.  
  85. void    FindExtKeyboards (short *numExtKbd, ADBAddrList addresses)    {
  86.  
  87.         short            numADBs, i;
  88.         ADBAddress        theAddr;
  89.         ADBDataBlock    macADBData;
  90.     
  91.     *numExtKbd = 0;
  92.     numADBs = CountADBs();
  93.     
  94.     for (i = 1; i <= numADBs; i++)
  95.     {
  96.         /* Get info about each ADB device:    */
  97.         theAddr = GetIndADB(&macADBData, i);
  98.         
  99.         if ( (macADBData.devType == Type_ExtKbd)
  100.              &&
  101.              (macADBData.origADBAddr == Addr_ExtKbd) )
  102.             
  103.             /* Extended keyboard found.             */
  104.             /* Store address and increase count. */
  105.             addresses[(*numExtKbd)++] = theAddr;
  106.     }
  107.     
  108. }    /* FindExtKeyboards */
  109.  
  110.  
  111.  
  112. /* ---------------------------------------------------
  113. ** Set the state of the LEDs on one extended keyboard.
  114. ** --------------------------------------------------- */
  115.  
  116. OSErr    Set1ADBLights (ADBAddress kbdAddress, LightStruct *lights)    {
  117.     
  118.         Boolean            opCompleted;
  119.         OSErr            err;
  120.         short            commandNum;
  121.         unsigned char    buffer[9];
  122.         char            lightByte;
  123.     
  124.     
  125.     /* Determine the current status of its LEDs: */
  126.     commandNum = (kbdAddress << 4) + Talk_Reg2;
  127.     opCompleted = FALSE;
  128.     ;
  129.     err = ADBOp((Ptr)&opCompleted, (ProcPtr)&ADBCompletion, (Ptr)buffer, commandNum);
  130.     if (err != noErr)    return (err);
  131.     
  132.     while    (!opCompleted)    ;            /* Wait for a reply. */
  133.     
  134.     /* Now that we've got the initial status of the LEDs,
  135.        convert Talk into a Listen command to change them: */
  136.        
  137.     commandNum = (commandNum & 0xFFF0) + Listen_Reg2;
  138.     
  139.     /* buffer contains the register value, which is stored as a length
  140.        byte followed by the bit settings. The low three bits of the
  141.        last byte hold the LED settings.                                    */
  142.         
  143.     lightByte = buffer[buffer[0]];
  144.  
  145.     /* Set the LED bits depending on how we want to change the lights: */
  146.     
  147.     if (lights->numLock == Light_On)                lightByte &= ~Bit_NumLock;
  148.     else if (lights->numLock == Light_Off)            lightByte |= Bit_NumLock;
  149.     else if (lights->numLock == Light_Toggle)        lightByte ^= Bit_NumLock;
  150.     
  151.     if (lights->capsLock == Light_On)                lightByte &= ~Bit_CapsLock;
  152.     else if (lights->capsLock == Light_Off)            lightByte |= Bit_CapsLock;
  153.     else if (lights->capsLock == Light_Toggle)        lightByte ^= Bit_CapsLock;
  154.  
  155.     if (lights->scrollLock == Light_On)                lightByte &= ~Bit_ScrollLock;
  156.     else if (lights->scrollLock == Light_Off)        lightByte |= Bit_ScrollLock;
  157.     else if (lights->scrollLock == Light_Toggle)    lightByte ^= Bit_ScrollLock;
  158.  
  159.     /* Stuff our modified byte back into the buffer    */
  160.     
  161.     buffer[buffer[0]] = lightByte;
  162.     
  163.     return ( ADBOp(nil, nil, (Ptr)buffer, commandNum) );
  164.     
  165. }    /* Set1ADBLights */
  166.     
  167.  
  168.  
  169. /* -------------------------------------------------------
  170. ** This routine is called when the ADB finishes responding
  171. ** to a command. We set a Boolean flag to TRUE so that the
  172. ** routine that issued the command will know that it has
  173. ** been completed.
  174. ** ------------------------------------------------------- */
  175.  
  176. pascal void    ADBCompletion (void)    {
  177.     
  178.      // short            commandNum;
  179.      //    Ptr                buffer;
  180.         Boolean            *opCompleted;
  181.             
  182.     
  183.     asm    {    
  184.         //    move.w    d0, commandNum;
  185.         //    move.l    a0, buffer;
  186.             move.l    a2, opCompleted;
  187.     }
  188.     
  189.     *opCompleted = TRUE;            /* Now, on with the show !!! */
  190.     
  191. }    /* ADBCompletion */
  192.  
  193.  
  194.  
  195. void    BlinkAllADBLights (void)    {
  196.  
  197.         short            numExtKbd, i, j, k;
  198.         ADBAddrList        addresses;
  199.         LightStruct        lights,
  200.                         blinkNum    = { Light_Toggle, Light_Same,   Light_Same },
  201.                         blinkCaps   = { Light_Same,   Light_Toggle, Light_Same },
  202.                         blinkScroll = { Light_Same,   Light_Same,   Light_Toggle };
  203.         long            finalTicks;
  204.         
  205.         
  206.     if (!hasADB || !hasExtendedKybd)    return;
  207.     
  208.     FindExtKeyboards(&numExtKbd, addresses);
  209.     
  210.     for (i = 0; i <= 7; ++i)        /* Even # so we end up where we started. */
  211.     {
  212.         for (j = 0; j <= numExtKbd - 1; ++j)
  213.         {
  214.             lights.numLock = Light_Toggle;
  215.             lights.capsLock = Light_Same;
  216.             lights.scrollLock = Light_Same;
  217.             Set1ADBLights (addresses[j], &lights);
  218.             Delay(8, &finalTicks);
  219.             ;
  220.             lights.numLock = Light_Toggle;
  221.             lights.capsLock = Light_Toggle;
  222.             lights.scrollLock = Light_Same;
  223.             Set1ADBLights (addresses[j], &lights);
  224.             Delay(8, &finalTicks);
  225.             ;
  226.             lights.numLock = Light_Same;
  227.             lights.capsLock = Light_Toggle;
  228.             lights.scrollLock = Light_Toggle;
  229.             Set1ADBLights (addresses[j], &lights);
  230.             Delay(8, &finalTicks);
  231.             ;
  232.             lights.numLock = Light_Same;
  233.             lights.capsLock = Light_Same;
  234.             lights.scrollLock = Light_Toggle;
  235.             Set1ADBLights (addresses[j], &lights);
  236.             Delay(8, &finalTicks);
  237.         }    /* j loop */
  238.  
  239.     }    /* i loop */
  240.     
  241.     //////////
  242.     
  243.     for (j = 0; j <= numExtKbd - 1; ++j)
  244.     {
  245.         for (k = 1; k <= 6; ++k)    /* Another even #. */    {
  246.             Set1ADBLights (addresses[j], &blinkNum);
  247.             Delay(8, &finalTicks);
  248.         }
  249.         for (k = 1; k <= 6; ++k)    {
  250.             Set1ADBLights (addresses[j], &blinkCaps);
  251.             Delay(8, &finalTicks);
  252.         }
  253.         for (k = 1; k <= 6; ++k)    {
  254.             Set1ADBLights (addresses[j], &blinkScroll);
  255.             Delay(8, &finalTicks);
  256.         }
  257.     }    /* j loop */
  258.         
  259. }    /* BlinkAllADBLights*/
  260.  
  261.  
  262.  
  263.  
  264.  
  265. /*    { end file = "ADBLights.c" }  */
  266.